package com.pingan.haofang.searchcloud.api.query.parser.visitor;

import com.pingan.haofang.searchcloud.api.query.parser.exception.SqlParseException;

import net.sf.jsqlparser.expression.AllComparisonExpression;
import net.sf.jsqlparser.expression.AnalyticExpression;
import net.sf.jsqlparser.expression.AnyComparisonExpression;
import net.sf.jsqlparser.expression.CaseExpression;
import net.sf.jsqlparser.expression.CastExpression;
import net.sf.jsqlparser.expression.DateValue;
import net.sf.jsqlparser.expression.DoubleValue;
import net.sf.jsqlparser.expression.ExpressionVisitor;
import net.sf.jsqlparser.expression.ExtractExpression;
import net.sf.jsqlparser.expression.Function;
import net.sf.jsqlparser.expression.IntervalExpression;
import net.sf.jsqlparser.expression.JdbcNamedParameter;
import net.sf.jsqlparser.expression.JdbcParameter;
import net.sf.jsqlparser.expression.JsonExpression;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.NullValue;
import net.sf.jsqlparser.expression.OracleHierarchicalExpression;
import net.sf.jsqlparser.expression.Parenthesis;
import net.sf.jsqlparser.expression.SignedExpression;
import net.sf.jsqlparser.expression.StringValue;
import net.sf.jsqlparser.expression.TimeValue;
import net.sf.jsqlparser.expression.TimestampValue;
import net.sf.jsqlparser.expression.UserVariable;
import net.sf.jsqlparser.expression.WhenClause;
import net.sf.jsqlparser.expression.WithinGroupExpression;
import net.sf.jsqlparser.expression.operators.arithmetic.Addition;
import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseAnd;
import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseOr;
import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor;
import net.sf.jsqlparser.expression.operators.arithmetic.Concat;
import net.sf.jsqlparser.expression.operators.arithmetic.Division;
import net.sf.jsqlparser.expression.operators.arithmetic.Modulo;
import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication;
import net.sf.jsqlparser.expression.operators.arithmetic.Subtraction;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.Between;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.ExistsExpression;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
import net.sf.jsqlparser.expression.operators.relational.InExpression;
import net.sf.jsqlparser.expression.operators.relational.IsNullExpression;
import net.sf.jsqlparser.expression.operators.relational.ItemsListVisitor;
import net.sf.jsqlparser.expression.operators.relational.LikeExpression;
import net.sf.jsqlparser.expression.operators.relational.Matches;
import net.sf.jsqlparser.expression.operators.relational.MinorThan;
import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
import net.sf.jsqlparser.expression.operators.relational.MultiExpressionList;
import net.sf.jsqlparser.expression.operators.relational.NotEqualsTo;
import net.sf.jsqlparser.expression.operators.relational.RegExpMatchOperator;
import net.sf.jsqlparser.expression.operators.relational.RegExpMySQLOperator;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.select.SubSelect;

public abstract class AbstractExpressionVisitor implements ExpressionVisitor, ItemsListVisitor {

    @Override
    public void visit(NullValue nullValue) {
        throw new SqlParseException("node [" + nullValue.toString() + "] is not support");
    }

    @Override
    public void visit(Function function) {
        throw new SqlParseException("node [" + function.toString() + "] is not support");
    }

    @Override
    public void visit(SignedExpression signedExpression) {
        throw new SqlParseException("node [" + signedExpression.toString() + "] is not support");
    }

    @Override
    public void visit(JdbcParameter jdbcParameter) {
        throw new SqlParseException("node [" + jdbcParameter.toString() + "] is not support");
    }

    @Override
    public void visit(JdbcNamedParameter jdbcNamedParameter) {
        throw new SqlParseException("node [" + jdbcNamedParameter.toString() + "] is not support");
    }

    @Override
    public void visit(DoubleValue doubleValue) {
        throw new SqlParseException("node [" + doubleValue.toString() + "] is not support");
    }

    @Override
    public void visit(LongValue longValue) {
        throw new SqlParseException("node [" + longValue.toString() + "] is not support");
    }

    @Override
    public void visit(DateValue dateValue) {
        throw new SqlParseException("node [" + dateValue.toString() + "] is not support");
    }

    @Override
    public void visit(TimeValue timeValue) {
        throw new SqlParseException("node [" + timeValue.toString() + "] is not support");
    }

    @Override
    public void visit(TimestampValue timestampValue) {
        throw new SqlParseException("node [" + timestampValue.toString() + "] is not support");
    }

    @Override
    public void visit(Parenthesis parenthesis) {
        throw new SqlParseException("node [" + parenthesis.toString() + "] is not support");
    }

    @Override
    public void visit(StringValue stringValue) {
        throw new SqlParseException("node [" + stringValue.toString() + "] is not support");
    }

    @Override
    public void visit(Addition addition) {
        throw new SqlParseException("node [" + addition.toString() + "] is not support");
    }

    @Override
    public void visit(Division division) {
        throw new SqlParseException("node [" + division.toString() + "] is not support");
    }

    @Override
    public void visit(Multiplication multiplication) {
        throw new SqlParseException("node [" + multiplication.toString() + "] is not support");
    }

    @Override
    public void visit(Subtraction subtraction) {
        throw new SqlParseException("node [" + subtraction.toString() + "] is not support");
    }

    @Override
    public void visit(AndExpression andExpression) {
        throw new SqlParseException("node [" + andExpression.toString() + "] is not support");
    }

    @Override
    public void visit(OrExpression orExpression) {
        throw new SqlParseException("node [" + orExpression.toString() + "] is not support");
    }

    @Override
    public void visit(Between between) {
        throw new SqlParseException("node [" + between.toString() + "] is not support");
    }

    @Override
    public void visit(EqualsTo equalsTo) {
        throw new SqlParseException("node [" + equalsTo.toString() + "] is not support");
    }

    @Override
    public void visit(GreaterThan greaterThan) {
        throw new SqlParseException("node [" + greaterThan.toString() + "] is not support");
    }

    @Override
    public void visit(GreaterThanEquals greaterThanEquals) {
        throw new SqlParseException("node [" + greaterThanEquals.toString() + "] is not support");
    }

    @Override
    public void visit(InExpression inExpression) {
        throw new SqlParseException("node [" + inExpression.toString() + "] is not support");
    }

    @Override
    public void visit(IsNullExpression isNullExpression) {
        throw new SqlParseException("node [" + isNullExpression.toString() + "] is not support");
    }

    @Override
    public void visit(LikeExpression likeExpression) {
        throw new SqlParseException("node [" + likeExpression.toString() + "] is not support");
    }

    @Override
    public void visit(MinorThan minorThan) {
        throw new SqlParseException("node [" + minorThan.toString() + "] is not support");
    }

    @Override
    public void visit(MinorThanEquals minorThanEquals) {
        throw new SqlParseException("node [" + minorThanEquals.toString() + "] is not support");
    }

    @Override
    public void visit(NotEqualsTo notEqualsTo) {
        throw new SqlParseException("node [" + notEqualsTo.toString() + "] is not support");
    }

    @Override
    public void visit(Column tableColumn) {
        throw new SqlParseException("node [" + tableColumn.toString() + "] is not support");
    }

    @Override
    public void visit(SubSelect subSelect) {
        throw new SqlParseException("node [" + subSelect.toString() + "] is not support");
    }

    @Override
    public void visit(CaseExpression caseExpression) {
        throw new SqlParseException("node [" + caseExpression.toString() + "] is not support");
    }

    @Override
    public void visit(WhenClause whenClause) {
        throw new SqlParseException("node [" + whenClause.toString() + "] is not support");
    }

    @Override
    public void visit(ExistsExpression existsExpression) {
        throw new SqlParseException("node [" + existsExpression.toString() + "] is not support");
    }

    @Override
    public void visit(AllComparisonExpression allComparisonExpression) {
        throw new SqlParseException("node [" + allComparisonExpression.toString() + "] is not support");
    }

    @Override
    public void visit(AnyComparisonExpression anyComparisonExpression) {
        throw new SqlParseException("node [" + anyComparisonExpression.toString() + "] is not support");
    }

    @Override
    public void visit(Concat concat) {
        throw new SqlParseException("node [" + concat.toString() + "] is not support");
    }

    @Override
    public void visit(Matches matches) {
        throw new SqlParseException("node [" + matches.toString() + "] is not support");
    }

    @Override
    public void visit(BitwiseAnd bitwiseAnd) {
        throw new SqlParseException("node [" + bitwiseAnd.toString() + "] is not support");
    }

    @Override
    public void visit(BitwiseOr bitwiseOr) {
        throw new SqlParseException("node [" + bitwiseOr.toString() + "] is not support");
    }

    @Override
    public void visit(BitwiseXor bitwiseXor) {
        throw new SqlParseException("node [" + bitwiseXor.toString() + "] is not support");
    }

    @Override
    public void visit(CastExpression cast) {
        throw new SqlParseException("node [" + cast.toString() + "] is not support");
    }

    @Override
    public void visit(Modulo modulo) {
        throw new SqlParseException("node [" + modulo.toString() + "] is not support");
    }

    @Override
    public void visit(AnalyticExpression aexpr) {
        throw new SqlParseException("node [" + aexpr.toString() + "] is not support");
    }

    @Override
    public void visit(WithinGroupExpression wgexpr) {
        throw new SqlParseException("node [" + wgexpr.toString() + "] is not support");
    }

    @Override
    public void visit(ExtractExpression eexpr) {
        throw new SqlParseException("node [" + eexpr.toString() + "] is not support");
    }

    @Override
    public void visit(IntervalExpression iexpr) {
        throw new SqlParseException("node [" + iexpr.toString() + "] is not support");
    }

    @Override
    public void visit(OracleHierarchicalExpression oexpr) {
        throw new SqlParseException("node [" + oexpr.toString() + "] is not support");
    }

    @Override
    public void visit(RegExpMatchOperator rexpr) {
        throw new SqlParseException("node [" + rexpr.toString() + "] is not support");
    }

    @Override
    public void visit(JsonExpression jsonExpr) {
        throw new SqlParseException("node [" + jsonExpr.toString() + "] is not support");
    }

    @Override
    public void visit(RegExpMySQLOperator regExpMySQLOperator) {
        throw new SqlParseException("node [" + regExpMySQLOperator.toString() + "] is not support");
    }

    @Override
    public void visit(UserVariable var) {
        throw new SqlParseException("node [" + var.toString() + "] is not support");
    }

    @Override
    public void visit(ExpressionList expressionList) {
        throw new SqlParseException("node [" + expressionList.toString() + "] is not support");
    }

    @Override
    public void visit(MultiExpressionList multiExprList) {
        throw new SqlParseException("node [" + multiExprList.toString() + "] is not support");
    }

    public void endVisit() {
    }

}
